#!/usr/bin/env node

/**
 * CloudBase AI 配置文件硬链接修复脚本
 * 用于确保所有 AI 编辑器的配置文件都指向同一个源文件
 */

import fs from "fs";
import path from "path";
import readline from "readline";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const projectRoot = path.resolve(__dirname, "..");

// Color definitions
const colors = {
  RED: "\x1b[0;31m",
  GREEN: "\x1b[0;32m",
  YELLOW: "\x1b[1;33m",
  BLUE: "\x1b[0;34m",
  NC: "\x1b[0m", // No Color
};

// Configuration
const RULES_SOURCE = "config/.cursor/rules/cloudbase-rules.mdc";
const RULES_TARGETS = [
  "config/.trae/rules/cloudbase-rules.md",
  "config/.windsurf/rules/cloudbase-rules.md",
  "config/.roo/rules/cloudbaase-rules.md",
  "config/.lingma/rules/cloudbaase-rules.md",
  "config/.qoder/rules/cloudbase-rules.md",
  "config/.rules/cloudbase-rules.md",
  "config/.rules/cloudbase-rules.mdc",
  "config/.clinerules/cloudbase-rules.mdc",
  "config/.github/copilot-instructions.md",
  "config/.comate/rules/cloudbase-rules.mdr",
  "config/.augment-guidelines",
  "config/CLAUDE.md",
  "config/.gemini/GEMINI.md",
  "config/AGENTS.md",
  "config/.qwen/QWEN.md",
  "config/CODEBUDDY.md",
];

const MCP_SOURCE = "config/.mcp.json";
const MCP_TARGETS = [".mcp.json"];

const SKILLS_SOURCE_DIR = "config/.claude/skills";
const SKILLS_TARGET_DIR = "config/.codebuddy/skills";
const RULES_DIR = "config/rules";

/**
 * Get file inode number
 * @param {string} filePath - File path
 * @returns {number|null} Inode number or null if file doesn't exist
 */
function getInode(filePath) {
  try {
    const fullPath = path.join(projectRoot, filePath);
    const stats = fs.statSync(fullPath);
    return stats.ino;
  } catch (error) {
    return null;
  }
}

/**
 * Check if two files are hard linked (same inode)
 * @param {string} sourcePath - Source file path
 * @param {string} targetPath - Target file path
 * @returns {boolean} True if files are hard linked
 */
function checkHardLinkStatus(sourcePath, targetPath) {
  const sourceInode = getInode(sourcePath);
  const targetInode = getInode(targetPath);

  if (sourceInode === null || targetInode === null) {
    return false;
  }

  return sourceInode === targetInode;
}

/**
 * Create hard link
 * @param {string} sourcePath - Source file path
 * @param {string} targetPath - Target file path
 * @returns {boolean} True if successful
 */
function createHardLink(sourcePath, targetPath) {
  try {
    const sourceFullPath = path.join(projectRoot, sourcePath);
    const targetFullPath = path.join(projectRoot, targetPath);

    // Ensure target directory exists
    const targetDir = path.dirname(targetFullPath);
    if (!fs.existsSync(targetDir)) {
      fs.mkdirSync(targetDir, { recursive: true });
    }

    // Remove existing file if it exists
    if (fs.existsSync(targetFullPath)) {
      fs.unlinkSync(targetFullPath);
    }

    // Create hard link
    fs.linkSync(sourceFullPath, targetFullPath);
    return true;
  } catch (error) {
    return false;
  }
}

/**
 * Prompt user for confirmation
 * @param {string} message - Prompt message
 * @returns {Promise<boolean>} True if user confirms
 */
function promptUser(message) {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  return new Promise((resolve) => {
    rl.question(message, (answer) => {
      rl.close();
      resolve(/^[Yy]$/.test(answer.trim()));
    });
  });
}

/**
 * Get all hard linked files for a given file
 * @param {string} filePath - File path
 * @returns {string[]} Array of hard linked file paths
 */
function getHardLinkedFiles(filePath) {
  const linkedFiles = [];
  const sourceInode = getInode(filePath);

  if (sourceInode === null) {
    return linkedFiles;
  }

  function searchDirectory(dir) {
    try {
      const entries = fs.readdirSync(dir, { withFileTypes: true });
      for (const entry of entries) {
        const fullPath = path.join(dir, entry.name);
        if (entry.isFile()) {
          try {
            const stats = fs.statSync(fullPath);
            if (stats.ino === sourceInode) {
              const relativePath = path.relative(projectRoot, fullPath);
              linkedFiles.push(relativePath);
            }
          } catch (error) {
            // Skip files that can't be accessed
          }
        } else if (entry.isDirectory()) {
          searchDirectory(fullPath);
        }
      }
    } catch (error) {
      // Skip directories that can't be accessed
    }
  }

  searchDirectory(projectRoot);
  return linkedFiles.sort();
}

/**
 * Get hard link count for a file
 * @param {string} filePath - File path
 * @returns {number} Hard link count
 */
function getHardLinkCount(filePath) {
  try {
    const fullPath = path.join(projectRoot, filePath);
    const stats = fs.statSync(fullPath);
    return stats.nlink;
  } catch (error) {
    return 0;
  }
}

/**
 * Process Rules configuration files hard links
 */
async function processRulesLinks() {
  console.log(
    `\n${colors.BLUE}📁 处理 Rules 配置文件: ${RULES_SOURCE}${colors.NC}`,
  );

  const sourcePath = path.join(projectRoot, RULES_SOURCE);
  if (!fs.existsSync(sourcePath)) {
    console.log(
      `${colors.RED}❌ 错误: 源文件 ${RULES_SOURCE} 不存在${colors.NC}`,
    );
    process.exit(1);
  }

  console.log(`${colors.GREEN}✅ 源文件存在: ${RULES_SOURCE}${colors.NC}`);

  const sourceInode = getInode(RULES_SOURCE);
  console.log(`${colors.BLUE}📋 源文件 inode: ${sourceInode}${colors.NC}`);

  console.log(`${colors.YELLOW}🔍 检查 Rules 硬链接状态...${colors.NC}`);

  const brokenLinks = [];
  const correctLinks = [];

  for (const target of RULES_TARGETS) {
    const targetPath = path.join(projectRoot, target);
    if (fs.existsSync(targetPath)) {
      const targetInode = getInode(target);
      if (targetInode === sourceInode) {
        console.log(`${colors.GREEN}✅ ${target} (正确链接)${colors.NC}`);
        correctLinks.push(target);
      } else {
        console.log(
          `${colors.RED}❌ ${target} (独立文件, inode: ${targetInode})${colors.NC}`,
        );
        brokenLinks.push(target);
      }
    } else {
      console.log(`${colors.YELLOW}⚠️  ${target} (文件不存在)${colors.NC}`);
      brokenLinks.push(target);
    }
  }

  if (brokenLinks.length === 0) {
    console.log(
      `\n${colors.GREEN}🎉 所有 Rules 配置文件都已正确硬链接！${colors.NC}`,
    );
    console.log(
      `${colors.BLUE}📊 总共 ${correctLinks.length + 1} 个硬链接${colors.NC}`,
    );
    return;
  }

  console.log(
    `\n${colors.YELLOW}🔧 需要修复的文件 (${brokenLinks.length} 个):${colors.NC}`,
  );
  for (const broken of brokenLinks) {
    console.log(`   - ${broken}`);
  }

  const shouldContinue = await promptUser(
    `\n${colors.YELLOW}❓ 是否继续修复这些 Rules 文件？这将删除独立副本并创建硬链接。 [y/N]${colors.NC} `,
  );

  if (!shouldContinue) {
    console.log(`${colors.BLUE}🚫 Rules 修复操作已取消${colors.NC}`);
    return;
  }

  console.log(`\n${colors.BLUE}🔧 开始修复 Rules 硬链接...${colors.NC}`);

  let fixedCount = 0;
  let errorCount = 0;

  for (const target of brokenLinks) {
    console.log(`${colors.YELLOW}🔄 处理: ${target}${colors.NC}`);

    const targetFullPath = path.join(projectRoot, target);
    const targetDir = path.dirname(targetFullPath);

    if (!fs.existsSync(targetDir)) {
      console.log(`   📁 创建目录: ${targetDir}`);
      fs.mkdirSync(targetDir, { recursive: true });
    }

    if (fs.existsSync(targetFullPath)) {
      console.log(`   🗑️  删除现有文件`);
      fs.unlinkSync(targetFullPath);
    }

    if (createHardLink(RULES_SOURCE, target)) {
      console.log(`   ${colors.GREEN}✅ 硬链接创建成功${colors.NC}`);
      fixedCount++;
    } else {
      console.log(`   ${colors.RED}❌ 硬链接创建失败${colors.NC}`);
      errorCount++;
    }
  }

  console.log(`\n${colors.BLUE}📊 Rules 修复完成统计:${colors.NC}`);
  console.log(`${colors.GREEN}✅ 成功修复: ${fixedCount} 个文件${colors.NC}`);
  if (errorCount > 0) {
    console.log(`${colors.RED}❌ 修复失败: ${errorCount} 个文件${colors.NC}`);
  }

  console.log(`\n${colors.BLUE}🔍 最终验证 Rules 硬链接状态...${colors.NC}`);
  const totalLinks = getHardLinkCount(RULES_SOURCE);
  console.log(`${colors.GREEN}🎉 总硬链接数: ${totalLinks}${colors.NC}`);

  console.log(`\n${colors.BLUE}📋 所有 Rules 硬链接文件:${colors.NC}`);
  const linkedFiles = getHardLinkedFiles(RULES_SOURCE);
  for (const file of linkedFiles) {
    console.log(file);
  }

  console.log(
    `\n${colors.GREEN}✨ Rules 硬链接修复完成！现在修改任何一个文件都会同步到所有其他文件。${colors.NC}`,
  );
}

/**
 * Process MCP configuration files hard links
 */
async function processMcpLinks() {
  console.log(
    `\n${colors.BLUE}📁 处理 MCP 配置文件: ${MCP_SOURCE}${colors.NC}`,
  );

  const sourcePath = path.join(projectRoot, MCP_SOURCE);
  if (!fs.existsSync(sourcePath)) {
    console.log(
      `${colors.RED}❌ 错误: 源文件 ${MCP_SOURCE} 不存在${colors.NC}`,
    );
    process.exit(1);
  }

  console.log(`${colors.GREEN}✅ 源文件存在: ${MCP_SOURCE}${colors.NC}`);

  const sourceInode = getInode(MCP_SOURCE);
  console.log(`${colors.BLUE}📋 源文件 inode: ${sourceInode}${colors.NC}`);

  console.log(`${colors.YELLOW}🔍 检查 MCP 硬链接状态...${colors.NC}`);

  const brokenLinks = [];
  const correctLinks = [];

  for (const target of MCP_TARGETS) {
    const targetPath = path.join(projectRoot, target);
    if (fs.existsSync(targetPath)) {
      const targetInode = getInode(target);
      if (targetInode === sourceInode) {
        console.log(`${colors.GREEN}✅ ${target} (正确链接)${colors.NC}`);
        correctLinks.push(target);
      } else {
        console.log(
          `${colors.RED}❌ ${target} (独立文件, inode: ${targetInode})${colors.NC}`,
        );
        brokenLinks.push(target);
      }
    } else {
      console.log(`${colors.YELLOW}⚠️  ${target} (文件不存在)${colors.NC}`);
      brokenLinks.push(target);
    }
  }

  if (brokenLinks.length === 0) {
    console.log(
      `\n${colors.GREEN}🎉 所有 MCP 配置文件都已正确硬链接！${colors.NC}`,
    );
    console.log(
      `${colors.BLUE}📊 总共 ${correctLinks.length + 1} 个硬链接${colors.NC}`,
    );
    return;
  }

  console.log(
    `\n${colors.YELLOW}🔧 需要修复的文件 (${brokenLinks.length} 个):${colors.NC}`,
  );
  for (const broken of brokenLinks) {
    console.log(`   - ${broken}`);
  }

  const shouldContinue = await promptUser(
    `\n${colors.YELLOW}❓ 是否继续修复这些文件？这将删除独立副本并创建硬链接。 [y/N]${colors.NC} `,
  );

  if (!shouldContinue) {
    console.log(`${colors.BLUE}🚫 操作已取消${colors.NC}`);
    return;
  }

  console.log(`\n${colors.BLUE}🔧 开始修复硬链接...${colors.NC}`);

  let fixedCount = 0;
  let errorCount = 0;

  for (const target of brokenLinks) {
    console.log(`${colors.YELLOW}🔄 处理: ${target}${colors.NC}`);

    const targetFullPath = path.join(projectRoot, target);
    const targetDir = path.dirname(targetFullPath);

    if (!fs.existsSync(targetDir)) {
      console.log(`   📁 创建目录: ${targetDir}`);
      fs.mkdirSync(targetDir, { recursive: true });
    }

    if (fs.existsSync(targetFullPath)) {
      console.log(`   🗑️  删除现有文件`);
      fs.unlinkSync(targetFullPath);
    }

    if (createHardLink(MCP_SOURCE, target)) {
      console.log(`   ${colors.GREEN}✅ 硬链接创建成功${colors.NC}`);
      fixedCount++;
    } else {
      console.log(`   ${colors.RED}❌ 硬链接创建失败${colors.NC}`);
      errorCount++;
    }
  }

  console.log(`\n${colors.BLUE}📊 MCP 修复完成统计:${colors.NC}`);
  console.log(`${colors.GREEN}✅ 成功修复: ${fixedCount} 个文件${colors.NC}`);
  if (errorCount > 0) {
    console.log(`${colors.RED}❌ 修复失败: ${errorCount} 个文件${colors.NC}`);
  }

  console.log(`\n${colors.BLUE}🔍 最终验证 MCP 硬链接状态...${colors.NC}`);
  const totalLinks = getHardLinkCount(MCP_SOURCE);
  console.log(`${colors.GREEN}🎉 总硬链接数: ${totalLinks}${colors.NC}`);

  console.log(`\n${colors.BLUE}📋 所有 MCP 硬链接文件:${colors.NC}`);
  const linkedFiles = getHardLinkedFiles(MCP_SOURCE);
  for (const file of linkedFiles) {
    console.log(file);
  }

  console.log(
    `\n${colors.GREEN}✨ MCP 硬链接修复完成！现在修改任何一个文件都会同步到所有其他文件。${colors.NC}`,
  );
}

/**
 * Sync skills directory recursively
 * @param {string} srcDir - Source directory
 * @param {string} destDir - Destination directory
 */
function syncSkillsDirectoryRecursive(srcDir, destDir) {
  if (!fs.existsSync(srcDir)) {
    return;
  }

  // Ensure destination directory exists
  if (!fs.existsSync(destDir)) {
    fs.mkdirSync(destDir, { recursive: true });
  }

  const entries = fs.readdirSync(srcDir, { withFileTypes: true });

  for (const entry of entries) {
    const srcPath = path.join(srcDir, entry.name);
    const destPath = path.join(destDir, entry.name);

    if (entry.isDirectory()) {
      syncSkillsDirectoryRecursive(srcPath, destPath);
    } else if (entry.isFile()) {
      // Create hard link for file
      try {
        if (fs.existsSync(destPath)) {
          fs.unlinkSync(destPath);
        }
        fs.linkSync(srcPath, destPath);
      } catch (error) {
        console.log(
          `   ${colors.RED}❌ 无法创建硬链接: ${entry.name}${colors.NC}`,
        );
      }
    }
  }
}

/**
 * Sync skills directory from .claude/skills to .codebuddy/skills
 */
async function syncSkillsDirectory() {
  console.log(
    `\n${colors.BLUE}📁 处理 Skills 目录同步: ${SKILLS_SOURCE_DIR} -> ${SKILLS_TARGET_DIR}${colors.NC}`,
  );

  const sourcePath = path.join(projectRoot, SKILLS_SOURCE_DIR);
  if (!fs.existsSync(sourcePath)) {
    console.log(
      `${colors.YELLOW}⚠️  源目录 ${SKILLS_SOURCE_DIR} 不存在，跳过${colors.NC}`,
    );
    return;
  }

  console.log(`${colors.GREEN}✅ 源目录存在: ${SKILLS_SOURCE_DIR}${colors.NC}`);

  const destPath = path.join(projectRoot, SKILLS_TARGET_DIR);

  console.log(`${colors.YELLOW}🔍 开始同步 Skills 目录...${colors.NC}`);

  syncSkillsDirectoryRecursive(sourcePath, destPath);

  console.log(`${colors.GREEN}✨ Skills 目录同步完成！${colors.NC}`);
}

/**
 * Copy directory recursively
 * @param {string} srcDir - Source directory
 * @param {string} destDir - Destination directory
 * @returns {{files: number, errors: number}} Copy statistics
 */
function copyDirectoryRecursive(srcDir, destDir) {
  let filesCount = 0;
  let errorsCount = 0;

  function copyRecursive(src, dest) {
    if (!fs.existsSync(src)) {
      return;
    }

    // Ensure destination directory exists
    if (!fs.existsSync(dest)) {
      fs.mkdirSync(dest, { recursive: true });
    }

    const entries = fs.readdirSync(src, { withFileTypes: true });

    for (const entry of entries) {
      const srcPath = path.join(src, entry.name);
      // Rename SKILL.md to rule.md when copying
      const destFileName = entry.name === "SKILL.md" ? "rule.md" : entry.name;
      const destPath = path.join(dest, destFileName);

      if (entry.isDirectory()) {
        copyRecursive(srcPath, destPath);
      } else if (entry.isFile()) {
        try {
          // Remove existing file if it exists
          if (fs.existsSync(destPath)) {
            fs.unlinkSync(destPath);
          }
          // Copy file
          fs.copyFileSync(srcPath, destPath);
          filesCount++;
        } catch (error) {
          console.log(
            `   ${colors.RED}❌ 无法复制文件: ${entry.name} - ${error.message}${colors.NC}`,
          );
          errorsCount++;
        }
      }
    }
  }

  copyRecursive(srcDir, destDir);

  return { files: filesCount, errors: errorsCount };
}

/**
 * Sync skills directory to rules directory, maintaining original structure
 */
async function syncSkillFiles() {
  console.log(
    `\n${colors.BLUE}📁 处理 Skills 目录同步到 rules 目录${colors.NC}`,
  );

  const skillsSourcePath = path.join(projectRoot, SKILLS_SOURCE_DIR);
  if (!fs.existsSync(skillsSourcePath)) {
    console.log(
      `${colors.YELLOW}⚠️  源目录 ${SKILLS_SOURCE_DIR} 不存在，跳过${colors.NC}`,
    );
    return;
  }

  console.log(`${colors.GREEN}✅ 源目录存在: ${SKILLS_SOURCE_DIR}${colors.NC}`);

  const rulesDirPath = path.join(projectRoot, RULES_DIR);
  if (!fs.existsSync(rulesDirPath)) {
    fs.mkdirSync(rulesDirPath, { recursive: true });
  }

  console.log(
    `${colors.YELLOW}🔍 开始复制 Skills 目录到 rules 目录...${colors.NC}`,
  );
  console.log(`   ${colors.BLUE}源: ${SKILLS_SOURCE_DIR}${colors.NC}`);
  console.log(`   ${colors.BLUE}目标: ${RULES_DIR}${colors.NC}`);

  const stats = copyDirectoryRecursive(skillsSourcePath, rulesDirPath);

  console.log(`\n${colors.BLUE}📊 Skills 目录同步完成统计:${colors.NC}`);
  console.log(`${colors.GREEN}✅ 成功复制: ${stats.files} 个文件${colors.NC}`);
  if (stats.errors > 0) {
    console.log(`${colors.RED}❌ 复制失败: ${stats.errors} 个文件${colors.NC}`);
  }

  console.log(
    `\n${colors.GREEN}✨ Skills 目录同步完成！已保持原有目录结构和文件名。${colors.NC}`,
  );
}

/**
 * Sync rules directory to IDE-specific rules directories using hard links
 */
async function syncRulesToIDEDirectories() {
  console.log(
    `\n${colors.BLUE}📁 处理 Rules 目录同步到 IDE 特定目录${colors.NC}`,
  );

  const rulesSourcePath = path.join(projectRoot, RULES_DIR);
  if (!fs.existsSync(rulesSourcePath)) {
    console.log(
      `${colors.YELLOW}⚠️  源目录 ${RULES_DIR} 不存在，跳过${colors.NC}`,
    );
    return;
  }

  console.log(`${colors.GREEN}✅ 源目录存在: ${RULES_DIR}${colors.NC}`);

  // IDE-specific rules directories configuration
  // Each entry: { dir: string, convertMdToMdc: boolean }
  const ideRulesConfigs = [
    { dir: "config/.qoder/rules", convertMdToMdc: false },
    { dir: "config/.cursor/rules", convertMdToMdc: true },
    { dir: "config/.agent/rules", convertMdToMdc: false },
    { dir: "config/.trae/rules", convertMdToMdc: false },
    { dir: "config/.windsurf/rules", convertMdToMdc: false },
    { dir: "config/.clinerules", convertMdToMdc: false },
  ];

  console.log(
    `${colors.YELLOW}🔍 开始同步 Rules 目录到 IDE 特定目录...${colors.NC}`,
  );

  let totalFiles = 0;
  let totalErrors = 0;

  for (const config of ideRulesConfigs) {
    const ideRulesDir = config.dir;
    const convertMdToMdc = config.convertMdToMdc;
    const ideRulesPath = path.join(projectRoot, ideRulesDir);
    
    console.log(`\n${colors.BLUE}📂 处理: ${ideRulesDir}${colors.NC}`);
    if (convertMdToMdc) {
      console.log(`   ${colors.YELLOW}📝 将 .md 文件转换为 .mdc 格式${colors.NC}`);
    }

    // Ensure target directory exists
    if (!fs.existsSync(ideRulesPath)) {
      fs.mkdirSync(ideRulesPath, { recursive: true });
      console.log(`   📁 创建目录: ${ideRulesDir}`);
    }

    // Recursively sync files
    function syncRulesRecursive(srcDir, destDir) {
      if (!fs.existsSync(srcDir)) {
        return;
      }

      const entries = fs.readdirSync(srcDir, { withFileTypes: true });

      for (const entry of entries) {
        const srcPath = path.join(srcDir, entry.name);
        let destFileName = entry.name;
        
        // Convert .md to .mdc for Cursor
        if (convertMdToMdc && entry.isFile() && entry.name.endsWith('.md')) {
          destFileName = entry.name.replace(/\.md$/, '.mdc');
        }
        
        const destPath = path.join(destDir, destFileName);

        if (entry.isDirectory()) {
          // Create subdirectory if it doesn't exist
          if (!fs.existsSync(destPath)) {
            fs.mkdirSync(destPath, { recursive: true });
          }
          syncRulesRecursive(srcPath, destPath);
        } else if (entry.isFile()) {
          try {
            if (convertMdToMdc && entry.name.endsWith('.md')) {
              // For Cursor, copy file content and rename extension
              if (fs.existsSync(destPath)) {
                fs.unlinkSync(destPath);
              }
              fs.copyFileSync(srcPath, destPath);
              totalFiles++;
            } else {
              // For other IDEs, create hard link
              if (fs.existsSync(destPath)) {
                // Check if it's already a hard link
                const srcStats = fs.statSync(srcPath);
                const destStats = fs.statSync(destPath);
                
                if (srcStats.ino === destStats.ino) {
                  // Already hard linked, skip
                  continue;
                } else {
                  // Remove existing file and create hard link
                  fs.unlinkSync(destPath);
                }
              }
              
              fs.linkSync(srcPath, destPath);
              totalFiles++;
            }
          } catch (error) {
            console.log(
              `   ${colors.RED}❌ 无法同步文件: ${entry.name} - ${error.message}${colors.NC}`,
            );
            totalErrors++;
          }
        }
      }
    }

    syncRulesRecursive(rulesSourcePath, ideRulesPath);
    console.log(`   ${colors.GREEN}✅ ${ideRulesDir} 同步完成${colors.NC}`);
  }

  console.log(`\n${colors.BLUE}📊 Rules 目录同步完成统计:${colors.NC}`);
  console.log(`${colors.GREEN}✅ 成功创建硬链接: ${totalFiles} 个文件${colors.NC}`);
  if (totalErrors > 0) {
    console.log(`${colors.RED}❌ 创建失败: ${totalErrors} 个文件${colors.NC}`);
  }

  console.log(
    `\n${colors.GREEN}✨ Rules 目录同步完成！所有文件已通过硬链接同步。${colors.NC}`,
  );
}

/**
 * Main function
 */
async function main() {
  console.log(
    `${colors.BLUE}🔧 CloudBase AI 配置文件硬链接修复工具${colors.NC}`,
  );
  console.log("==================================================");

  try {
    await processRulesLinks();
    await processMcpLinks();
    await syncSkillsDirectory();
    await syncSkillFiles();
    await syncRulesToIDEDirectories();

    console.log(`\n${colors.GREEN}🎉 所有操作完成！${colors.NC}`);
  } catch (error) {
    console.error(
      `\n${colors.RED}❌ 脚本执行失败: ${error.message}${colors.NC}`,
    );
    process.exit(1);
  }
}

// Run main function
main().catch(console.error);
